//auto gen by paipai.java.augogen ver 3.0.0
//author skyzhuang
//source idl: com.erp.account.dao.idl.GetBusinessUnitsByFilterReq.java


#ifndef ERP_ACCOUNT_DDO_CBUSINESSUNITSFILTERDDO_BY_AUTOGEN_V5_H
#define ERP_ACCOUNT_DDO_CBUSINESSUNITSFILTERDDO_BY_AUTOGEN_V5_H


#include "app_platform/intf_serializable.h"
#include <set>
#include <bitset>
#include <map>
#include <string>
#include <sstream>
#include <iostream>


namespace erp
{
namespace account
{
namespace ddo
{


class CBusinessUnitsFilterDdo : public ISerializable
{
	public:
		std::string m_sLastErrMsg;///<错误信息

		/**
		 * 版本号
		 *
		 * 版本 >= 0
		 */
		uint32_t dwVersion;

		/**
		 * cVersion_u uflag field
		 */
		uint8_t cVersion_u; //optional flag

		/**
		 * 页码，从0开始，必填
		 *
		 * 版本 >= 0
		 */
		uint32_t dwPage;

		/**
		 * cPage_u uflag field
		 */
		uint8_t cPage_u; //optional flag

		/**
		 * 页面大小，服务通过配置进行最大值限制，必填
		 *
		 * 版本 >= 0
		 */
		uint32_t dwPageSize;

		/**
		 * cPageSize_u uflag field
		 */
		uint8_t cPageSize_u; //optional flag

		/**
		 * 排序方式，参见相关枚举定义，必填
		 *
		 * 版本 >= 0
		 */
		uint32_t dwOrderType;

		/**
		 * cOrderType_u uflag field
		 */
		uint8_t cOrderType_u; //optional flag

		/**
		 * 父来往单位SysNos
		 *
		 * 版本 >= 0
		 */
		std::set<uint64_t>  setParentSysNo;

		/**
		 * cParentSysNo_u uflag field
		 */
		uint8_t cParentSysNo_u; //optional flag

		/**
		 * 来往单位全称
		 *
		 * 版本 >= 0
		 */
		std::string strFullName;

		/**
		 * cFullName_u uflag field
		 */
		uint8_t cFullName_u; //optional flag

		/**
		 * 来往单位简称
		 *
		 * 版本 >= 0
		 */
		std::string strName;

		/**
		 * cName_u uflag field
		 */
		uint8_t cName_u; //optional flag

		/**
		 * 来往单位编码
		 *
		 * 版本 >= 0
		 */
		std::string strCode;

		/**
		 * cCode_u uflag field
		 */
		uint8_t cCode_u; //optional flag

		/**
		 * 来往单位拼音码
		 *
		 * 版本 >= 0
		 */
		std::string strPinyinCode;

		/**
		 * cPinyinCode_u uflag field
		 */
		uint8_t cPinyinCode_u; //optional flag

		/**
		 * 状态
		 *
		 * 版本 >= 0
		 */
		std::set<uint32_t>  setStatus;

		/**
		 * cStatus_u uflag field
		 */
		uint8_t cStatus_u; //optional flag

		/**
		 * 包含属性，且或关系由PropertyOption指定
		 *
		 * 版本 >= 0
		 */
		std::bitset<32>  bitsetPropertyInclude;

		/**
		 * cPropertyInclude_u uflag field
		 */
		uint8_t cPropertyInclude_u; //optional flag

		/**
		 * 包含属性选项：0：且的关系；1，或的关系
		 *
		 * 版本 >= 0
		 */
		uint16_t wPropertyOption;

		/**
		 * cPropertyOption_u uflag field
		 */
		uint8_t cPropertyOption_u; //optional flag

		/**
		 * 排除属性，与PropertyInclude为且关系 
		 *
		 * 版本 >= 0
		 */
		std::bitset<32>  bitsetPropertyExclude;

		/**
		 * cPropertyExclude_u uflag field
		 */
		uint8_t cPropertyExclude_u; //optional flag

		/**
		 * 扩展
		 *
		 * 版本 >= 0
		 */
		std::map<std::string,std::string>  mapExtern;

		/**
		 * cExtern_u uflag field
		 */
		uint8_t cExtern_u; //optional flag




	public:
		CBusinessUnitsFilterDdo():
		dwVersion(0),
		cVersion_u(0),
		dwPage(0),
		cPage_u(0),
		dwPageSize(0),
		cPageSize_u(0),
		dwOrderType(0),
		cOrderType_u(0),
		cParentSysNo_u(0),
		cFullName_u(0),
		cName_u(0),
		cCode_u(0),
		cPinyinCode_u(0),
		cStatus_u(0),
		cPropertyInclude_u(0),
		wPropertyOption(0),
		cPropertyOption_u(0),
		cPropertyExclude_u(0),
		cExtern_u(0) {}
				CBusinessUnitsFilterDdo& operator = (const CBusinessUnitsFilterDdo& obj){

			this->dwVersion = obj.dwVersion;
			this->dwPage = obj.dwPage;
			this->dwPageSize = obj.dwPageSize;
			this->dwOrderType = obj.dwOrderType;
			this->setParentSysNo = obj.setParentSysNo;
			this->strFullName = obj.strFullName;
			this->strName = obj.strName;
			this->strCode = obj.strCode;
			this->strPinyinCode = obj.strPinyinCode;
			this->setStatus = obj.setStatus;
			this->bitsetPropertyInclude = obj.bitsetPropertyInclude;
			this->wPropertyOption = obj.wPropertyOption;
			this->bitsetPropertyExclude = obj.bitsetPropertyExclude;
			this->mapExtern = obj.mapExtern;
			this->cVersion_u = obj.cVersion_u;
			this->cPage_u = obj.cPage_u;
			this->cPageSize_u = obj.cPageSize_u;
			this->cOrderType_u = obj.cOrderType_u;
			this->cParentSysNo_u = obj.cParentSysNo_u;
			this->cFullName_u = obj.cFullName_u;
			this->cName_u = obj.cName_u;
			this->cCode_u = obj.cCode_u;
			this->cPinyinCode_u = obj.cPinyinCode_u;
			this->cStatus_u = obj.cStatus_u;
			this->cPropertyInclude_u = obj.cPropertyInclude_u;
			this->cPropertyOption_u = obj.cPropertyOption_u;
			this->cPropertyExclude_u = obj.cPropertyExclude_u;
			this->cExtern_u = obj.cExtern_u;
			return *this;
		}

	public:


		/**
		 * 是否设置版本号了
		 * 
		 * @param uint32_t:dwVersion
		 *  
		 * 
		 */
		 bool  IsVersionSet() const{
				 return  cVersion_u != 0;
		}


		/**
		 * 获取uflag版本号了
		 * 
		 * @param uint32_t:dwVersion
		 *  
		 * 
		 */
		 const uint8_t   GetVersionUFlag() const{
				 return  cVersion_u;
		}


		/**
		 * 设置版本号
		 * 
		 * @param uint32_t:dwVersion
		 *  
		 * 
		 */
		 void  SetVersion( const uint32_t& sVal, uint8_t cUFlag=1){
				dwVersion = sVal;
				cVersion_u = cUFlag;
		}


		/**
		 * 获取版本号
		 * 
		 * @return dwVersion value 类型为:uint32_t
		 * 
		 */
		 const uint32_t&  GetVersion() const {
				return dwVersion;
		}


		/**
		 * 是否设置页码，从0开始，必填了
		 * 
		 * @param uint32_t:dwPage
		 *  
		 * 
		 */
		 bool  IsPageSet() const{
				 return  cPage_u != 0;
		}


		/**
		 * 获取uflag页码，从0开始，必填了
		 * 
		 * @param uint32_t:dwPage
		 *  
		 * 
		 */
		 const uint8_t   GetPageUFlag() const{
				 return  cPage_u;
		}


		/**
		 * 设置页码，从0开始，必填
		 * 
		 * @param uint32_t:dwPage
		 *  
		 * 
		 */
		 void  SetPage( const uint32_t& sVal, uint8_t cUFlag=1){
				dwPage = sVal;
				cPage_u = cUFlag;
		}


		/**
		 * 获取页码，从0开始，必填
		 * 
		 * @return dwPage value 类型为:uint32_t
		 * 
		 */
		 const uint32_t&  GetPage() const {
				return dwPage;
		}


		/**
		 * 是否设置页面大小，服务通过配置进行最大值限制，必填了
		 * 
		 * @param uint32_t:dwPageSize
		 *  
		 * 
		 */
		 bool  IsPageSizeSet() const{
				 return  cPageSize_u != 0;
		}


		/**
		 * 获取uflag页面大小，服务通过配置进行最大值限制，必填了
		 * 
		 * @param uint32_t:dwPageSize
		 *  
		 * 
		 */
		 const uint8_t   GetPageSizeUFlag() const{
				 return  cPageSize_u;
		}


		/**
		 * 设置页面大小，服务通过配置进行最大值限制，必填
		 * 
		 * @param uint32_t:dwPageSize
		 *  
		 * 
		 */
		 void  SetPageSize( const uint32_t& sVal, uint8_t cUFlag=1){
				dwPageSize = sVal;
				cPageSize_u = cUFlag;
		}


		/**
		 * 获取页面大小，服务通过配置进行最大值限制，必填
		 * 
		 * @return dwPageSize value 类型为:uint32_t
		 * 
		 */
		 const uint32_t&  GetPageSize() const {
				return dwPageSize;
		}


		/**
		 * 是否设置排序方式，参见相关枚举定义，必填了
		 * 
		 * @param uint32_t:dwOrderType
		 *  
		 * 
		 */
		 bool  IsOrderTypeSet() const{
				 return  cOrderType_u != 0;
		}


		/**
		 * 获取uflag排序方式，参见相关枚举定义，必填了
		 * 
		 * @param uint32_t:dwOrderType
		 *  
		 * 
		 */
		 const uint8_t   GetOrderTypeUFlag() const{
				 return  cOrderType_u;
		}


		/**
		 * 设置排序方式，参见相关枚举定义，必填
		 * 
		 * @param uint32_t:dwOrderType
		 *  
		 * 
		 */
		 void  SetOrderType( const uint32_t& sVal, uint8_t cUFlag=1){
				dwOrderType = sVal;
				cOrderType_u = cUFlag;
		}


		/**
		 * 获取排序方式，参见相关枚举定义，必填
		 * 
		 * @return dwOrderType value 类型为:uint32_t
		 * 
		 */
		 const uint32_t&  GetOrderType() const {
				return dwOrderType;
		}


		/**
		 * 是否设置父来往单位SysNos了
		 * 
		 * @param std::set<uint64_t> :setParentSysNo
		 *  
		 * 
		 */
		 bool  IsParentSysNoSet() const{
				 return  cParentSysNo_u != 0;
		}


		/**
		 * 获取uflag父来往单位SysNos了
		 * 
		 * @param std::set<uint64_t> :setParentSysNo
		 *  
		 * 
		 */
		 const uint8_t   GetParentSysNoUFlag() const{
				 return  cParentSysNo_u;
		}


		/**
		 * 设置父来往单位SysNos
		 * 
		 * @param std::set<uint64_t> :setParentSysNo
		 *  
		 * 
		 */
		 void  SetParentSysNo( const std::set<uint64_t> & sVal, uint8_t cUFlag=1){
				setParentSysNo = sVal;
				cParentSysNo_u = cUFlag;
		}


		/**
		 * 获取父来往单位SysNos
		 * 
		 * @return setParentSysNo value 类型为:std::set<uint64_t> 
		 * 
		 */
		 const std::set<uint64_t> &  GetParentSysNo() const {
				return setParentSysNo;
		}


		/**
		 * 获取父来往单位SysNos
		 * 
		 * @return setParentSysNo value 类型为:std::set<uint64_t> 
		 * 
		 */
		 std::set<uint64_t> &  GetParentSysNo() {
				return setParentSysNo;
		}


		/**
		 * 是否设置来往单位全称了
		 * 
		 * @param std::string:strFullName
		 *  
		 * 
		 */
		 bool  IsFullNameSet() const{
				 return  cFullName_u != 0;
		}


		/**
		 * 获取uflag来往单位全称了
		 * 
		 * @param std::string:strFullName
		 *  
		 * 
		 */
		 const uint8_t   GetFullNameUFlag() const{
				 return  cFullName_u;
		}


		/**
		 * 设置来往单位全称
		 * 
		 * @param std::string:strFullName
		 *  
		 * 
		 */
		 void  SetFullName( const std::string& sVal, uint8_t cUFlag=1){
				strFullName = sVal;
				cFullName_u = cUFlag;
		}


		/**
		 * 获取来往单位全称
		 * 
		 * @return strFullName value 类型为:std::string
		 * 
		 */
		 const std::string&  GetFullName() const {
				return strFullName;
		}


		/**
		 * 获取来往单位全称
		 * 
		 * @return strFullName value 类型为:std::string
		 * 
		 */
		 std::string&  GetFullName() {
				return strFullName;
		}


		/**
		 * 是否设置来往单位简称了
		 * 
		 * @param std::string:strName
		 *  
		 * 
		 */
		 bool  IsNameSet() const{
				 return  cName_u != 0;
		}


		/**
		 * 获取uflag来往单位简称了
		 * 
		 * @param std::string:strName
		 *  
		 * 
		 */
		 const uint8_t   GetNameUFlag() const{
				 return  cName_u;
		}


		/**
		 * 设置来往单位简称
		 * 
		 * @param std::string:strName
		 *  
		 * 
		 */
		 void  SetName( const std::string& sVal, uint8_t cUFlag=1){
				strName = sVal;
				cName_u = cUFlag;
		}


		/**
		 * 获取来往单位简称
		 * 
		 * @return strName value 类型为:std::string
		 * 
		 */
		 const std::string&  GetName() const {
				return strName;
		}


		/**
		 * 获取来往单位简称
		 * 
		 * @return strName value 类型为:std::string
		 * 
		 */
		 std::string&  GetName() {
				return strName;
		}


		/**
		 * 是否设置来往单位编码了
		 * 
		 * @param std::string:strCode
		 *  
		 * 
		 */
		 bool  IsCodeSet() const{
				 return  cCode_u != 0;
		}


		/**
		 * 获取uflag来往单位编码了
		 * 
		 * @param std::string:strCode
		 *  
		 * 
		 */
		 const uint8_t   GetCodeUFlag() const{
				 return  cCode_u;
		}


		/**
		 * 设置来往单位编码
		 * 
		 * @param std::string:strCode
		 *  
		 * 
		 */
		 void  SetCode( const std::string& sVal, uint8_t cUFlag=1){
				strCode = sVal;
				cCode_u = cUFlag;
		}


		/**
		 * 获取来往单位编码
		 * 
		 * @return strCode value 类型为:std::string
		 * 
		 */
		 const std::string&  GetCode() const {
				return strCode;
		}


		/**
		 * 获取来往单位编码
		 * 
		 * @return strCode value 类型为:std::string
		 * 
		 */
		 std::string&  GetCode() {
				return strCode;
		}


		/**
		 * 是否设置来往单位拼音码了
		 * 
		 * @param std::string:strPinyinCode
		 *  
		 * 
		 */
		 bool  IsPinyinCodeSet() const{
				 return  cPinyinCode_u != 0;
		}


		/**
		 * 获取uflag来往单位拼音码了
		 * 
		 * @param std::string:strPinyinCode
		 *  
		 * 
		 */
		 const uint8_t   GetPinyinCodeUFlag() const{
				 return  cPinyinCode_u;
		}


		/**
		 * 设置来往单位拼音码
		 * 
		 * @param std::string:strPinyinCode
		 *  
		 * 
		 */
		 void  SetPinyinCode( const std::string& sVal, uint8_t cUFlag=1){
				strPinyinCode = sVal;
				cPinyinCode_u = cUFlag;
		}


		/**
		 * 获取来往单位拼音码
		 * 
		 * @return strPinyinCode value 类型为:std::string
		 * 
		 */
		 const std::string&  GetPinyinCode() const {
				return strPinyinCode;
		}


		/**
		 * 获取来往单位拼音码
		 * 
		 * @return strPinyinCode value 类型为:std::string
		 * 
		 */
		 std::string&  GetPinyinCode() {
				return strPinyinCode;
		}


		/**
		 * 是否设置状态了
		 * 
		 * @param std::set<uint32_t> :setStatus
		 *  
		 * 
		 */
		 bool  IsStatusSet() const{
				 return  cStatus_u != 0;
		}


		/**
		 * 获取uflag状态了
		 * 
		 * @param std::set<uint32_t> :setStatus
		 *  
		 * 
		 */
		 const uint8_t   GetStatusUFlag() const{
				 return  cStatus_u;
		}


		/**
		 * 设置状态
		 * 
		 * @param std::set<uint32_t> :setStatus
		 *  
		 * 
		 */
		 void  SetStatus( const std::set<uint32_t> & sVal, uint8_t cUFlag=1){
				setStatus = sVal;
				cStatus_u = cUFlag;
		}


		/**
		 * 获取状态
		 * 
		 * @return setStatus value 类型为:std::set<uint32_t> 
		 * 
		 */
		 const std::set<uint32_t> &  GetStatus() const {
				return setStatus;
		}


		/**
		 * 获取状态
		 * 
		 * @return setStatus value 类型为:std::set<uint32_t> 
		 * 
		 */
		 std::set<uint32_t> &  GetStatus() {
				return setStatus;
		}


		/**
		 * 是否设置包含属性，且或关系由PropertyOption指定了
		 * 
		 * @param std::bitset<32> :bitsetPropertyInclude
		 *  
		 * 
		 */
		 bool  IsPropertyIncludeSet() const{
				 return  cPropertyInclude_u != 0;
		}


		/**
		 * 获取uflag包含属性，且或关系由PropertyOption指定了
		 * 
		 * @param std::bitset<32> :bitsetPropertyInclude
		 *  
		 * 
		 */
		 const uint8_t   GetPropertyIncludeUFlag() const{
				 return  cPropertyInclude_u;
		}


		/**
		 * 设置包含属性，且或关系由PropertyOption指定
		 * 
		 * @param std::bitset<32> :bitsetPropertyInclude
		 *  
		 * 
		 */
		 void  SetPropertyInclude( const std::bitset<32> & sVal, uint8_t cUFlag=1){
				bitsetPropertyInclude = sVal;
				cPropertyInclude_u = cUFlag;
		}


		/**
		 * 获取包含属性，且或关系由PropertyOption指定
		 * 
		 * @return bitsetPropertyInclude value 类型为:std::bitset<32> 
		 * 
		 */
		 const std::bitset<32> &  GetPropertyInclude() const {
				return bitsetPropertyInclude;
		}


		/**
		 * 获取包含属性，且或关系由PropertyOption指定
		 * 
		 * @return bitsetPropertyInclude value 类型为:std::bitset<32> 
		 * 
		 */
		 std::bitset<32> &  GetPropertyInclude() {
				return bitsetPropertyInclude;
		}


		/**
		 * 是否设置包含属性选项：0：且的关系；1，或的关系了
		 * 
		 * @param uint16_t:wPropertyOption
		 *  
		 * 
		 */
		 bool  IsPropertyOptionSet() const{
				 return  cPropertyOption_u != 0;
		}


		/**
		 * 获取uflag包含属性选项：0：且的关系；1，或的关系了
		 * 
		 * @param uint16_t:wPropertyOption
		 *  
		 * 
		 */
		 const uint8_t   GetPropertyOptionUFlag() const{
				 return  cPropertyOption_u;
		}


		/**
		 * 设置包含属性选项：0：且的关系；1，或的关系
		 * 
		 * @param uint16_t:wPropertyOption
		 *  
		 * 
		 */
		 void  SetPropertyOption( const uint16_t& sVal, uint8_t cUFlag=1){
				wPropertyOption = sVal;
				cPropertyOption_u = cUFlag;
		}


		/**
		 * 获取包含属性选项：0：且的关系；1，或的关系
		 * 
		 * @return wPropertyOption value 类型为:uint16_t
		 * 
		 */
		 const uint16_t&  GetPropertyOption() const {
				return wPropertyOption;
		}


		/**
		 * 是否设置排除属性，与PropertyInclude为且关系 了
		 * 
		 * @param std::bitset<32> :bitsetPropertyExclude
		 *  
		 * 
		 */
		 bool  IsPropertyExcludeSet() const{
				 return  cPropertyExclude_u != 0;
		}


		/**
		 * 获取uflag排除属性，与PropertyInclude为且关系 了
		 * 
		 * @param std::bitset<32> :bitsetPropertyExclude
		 *  
		 * 
		 */
		 const uint8_t   GetPropertyExcludeUFlag() const{
				 return  cPropertyExclude_u;
		}


		/**
		 * 设置排除属性，与PropertyInclude为且关系 
		 * 
		 * @param std::bitset<32> :bitsetPropertyExclude
		 *  
		 * 
		 */
		 void  SetPropertyExclude( const std::bitset<32> & sVal, uint8_t cUFlag=1){
				bitsetPropertyExclude = sVal;
				cPropertyExclude_u = cUFlag;
		}


		/**
		 * 获取排除属性，与PropertyInclude为且关系 
		 * 
		 * @return bitsetPropertyExclude value 类型为:std::bitset<32> 
		 * 
		 */
		 const std::bitset<32> &  GetPropertyExclude() const {
				return bitsetPropertyExclude;
		}


		/**
		 * 获取排除属性，与PropertyInclude为且关系 
		 * 
		 * @return bitsetPropertyExclude value 类型为:std::bitset<32> 
		 * 
		 */
		 std::bitset<32> &  GetPropertyExclude() {
				return bitsetPropertyExclude;
		}


		/**
		 * 是否设置扩展了
		 * 
		 * @param std::map<std::string,std::string> :mapExtern
		 *  
		 * 
		 */
		 bool  IsExternSet() const{
				 return  cExtern_u != 0;
		}


		/**
		 * 获取uflag扩展了
		 * 
		 * @param std::map<std::string,std::string> :mapExtern
		 *  
		 * 
		 */
		 const uint8_t   GetExternUFlag() const{
				 return  cExtern_u;
		}


		/**
		 * 设置扩展
		 * 
		 * @param std::map<std::string,std::string> :mapExtern
		 *  
		 * 
		 */
		 void  SetExtern( const std::map<std::string,std::string> & sVal, uint8_t cUFlag=1){
				mapExtern = sVal;
				cExtern_u = cUFlag;
		}


		/**
		 * 获取扩展
		 * 
		 * @return mapExtern value 类型为:std::map<std::string,std::string> 
		 * 
		 */
		 const std::map<std::string,std::string> &  GetExtern() const {
				return mapExtern;
		}


		/**
		 * 获取扩展
		 * 
		 * @return mapExtern value 类型为:std::map<std::string,std::string> 
		 * 
		 */
		 std::map<std::string,std::string> &  GetExtern() {
				return mapExtern;
		}

		virtual bool Serialize(CByteStreamNetwork& bs){
		
			uint32_t dwMyLen = 0;
			if(bs.isStoring()) //for write in buffer
			{
				//can not larger than 1 M.
				CByteStreamNetwork bsDummy(NULL, 1024 * 1024, false);
				//bsDummy for precheck the xo size...
				bsDummy.isStoring(true);
				Serialize_i(bsDummy);
				dwMyLen = bsDummy.getWrittenLength();
				bs & dwMyLen;
				Serialize_i(bs);
			}
			else
			{    //for read from buffer
				bs & dwMyLen;
				uint32_t dwReadedLen = bs.getReadLength();
				Serialize_i(bs);
				dwReadedLen = bs.getReadLength() - dwReadedLen;
				// dwReadedLen for the size of xo
				if( dwReadedLen > dwMyLen ){
					return false;
				}
				//go through the unwanted mem position...
				bs.goForward( dwMyLen - dwReadedLen );
			}

			return bs.isGood();
		}

		bool Serialize_i(CByteStreamNetwork& bsTmp){

			bsTmp & dwVersion; // 序列化版本号 类型为uint32_t
			bsTmp & cVersion_u; // 序列化uflag 类型为uint8_t
			bsTmp & dwPage; // 序列化页码，从0开始，必填 类型为uint32_t
			bsTmp & cPage_u; // 序列化uflag 类型为uint8_t
			bsTmp & dwPageSize; // 序列化页面大小，服务通过配置进行最大值限制，必填 类型为uint32_t
			bsTmp & cPageSize_u; // 序列化uflag 类型为uint8_t
			bsTmp & dwOrderType; // 序列化排序方式，参见相关枚举定义，必填 类型为uint32_t
			bsTmp & cOrderType_u; // 序列化uflag 类型为uint8_t
			bsTmp & setParentSysNo; // 序列化父来往单位SysNos 类型为Set
			bsTmp & cParentSysNo_u; // 序列化uflag 类型为uint8_t
			bsTmp & strFullName; // 序列化来往单位全称 类型为String
			bsTmp & cFullName_u; // 序列化uflag 类型为uint8_t
			bsTmp & strName; // 序列化来往单位简称 类型为String
			bsTmp & cName_u; // 序列化uflag 类型为uint8_t
			bsTmp & strCode; // 序列化来往单位编码 类型为String
			bsTmp & cCode_u; // 序列化uflag 类型为uint8_t
			bsTmp & strPinyinCode; // 序列化来往单位拼音码 类型为String
			bsTmp & cPinyinCode_u; // 序列化uflag 类型为uint8_t
			bsTmp & setStatus; // 序列化状态 类型为Set
			bsTmp & cStatus_u; // 序列化uflag 类型为uint8_t
			bsTmp & bitsetPropertyInclude; // 序列化包含属性，且或关系由PropertyOption指定 类型为BitSet
			bsTmp & cPropertyInclude_u; // 序列化uflag 类型为uint8_t
			bsTmp & wPropertyOption; // 序列化包含属性选项：0：且的关系；1，或的关系 类型为uint16_t
			bsTmp & cPropertyOption_u; // 序列化uflag 类型为uint8_t
			bsTmp & bitsetPropertyExclude; // 序列化排除属性，与PropertyInclude为且关系  类型为BitSet
			bsTmp & cPropertyExclude_u; // 序列化uflag 类型为uint8_t
			bsTmp & mapExtern; // 序列化扩展 类型为Map
			bsTmp & cExtern_u; // 序列化uflag 类型为uint8_t
			return bsTmp.isGood();
		}

		const char* GetLastErrMsg() const{
			return m_sLastErrMsg.c_str();
		}

		bool VerifyBusinessUnitsFilterDdo(){

			if(!IsVersionSet()){
				m_sLastErrMsg = "Miss Param:version";
				return false;
			}

			if(!IsPageSet()){
				m_sLastErrMsg = "Miss Param:page";
				return false;
			}

			if(!IsPageSizeSet()){
				m_sLastErrMsg = "Miss Param:pageSize";
				return false;
			}

			if(!IsOrderTypeSet()){
				m_sLastErrMsg = "Miss Param:orderType";
				return false;
			}

			if(!IsParentSysNoSet()){
				m_sLastErrMsg = "Miss Param:parentSysNo";
				return false;
			}

			if(!IsFullNameSet()){
				m_sLastErrMsg = "Miss Param:fullName";
				return false;
			}

			if(!IsNameSet()){
				m_sLastErrMsg = "Miss Param:name";
				return false;
			}

			if(!IsCodeSet()){
				m_sLastErrMsg = "Miss Param:code";
				return false;
			}

			if(!IsPinyinCodeSet()){
				m_sLastErrMsg = "Miss Param:pinyinCode";
				return false;
			}

			if(!IsStatusSet()){
				m_sLastErrMsg = "Miss Param:status";
				return false;
			}

			if(!IsPropertyIncludeSet()){
				m_sLastErrMsg = "Miss Param:propertyInclude";
				return false;
			}

			if(!IsPropertyOptionSet()){
				m_sLastErrMsg = "Miss Param:propertyOption";
				return false;
			}

			if(!IsPropertyExcludeSet()){
				m_sLastErrMsg = "Miss Param:propertyExclude";
				return false;
			}

			if(!IsExternSet()){
				m_sLastErrMsg = "Miss Param:extern";
				return false;
			}
			return true;
		}

		void DumpData(std::ostream& oss) const{
		
			oss<<"[dwVersion:"<<dwVersion<<"] ";
			oss<<"[cVersion_u:"<<(int)cVersion_u<<"] ";
			oss<<"[dwPage:"<<dwPage<<"] ";
			oss<<"[cPage_u:"<<(int)cPage_u<<"] ";
			oss<<"[dwPageSize:"<<dwPageSize<<"] ";
			oss<<"[cPageSize_u:"<<(int)cPageSize_u<<"] ";
			oss<<"[dwOrderType:"<<dwOrderType<<"] ";
			oss<<"[cOrderType_u:"<<(int)cOrderType_u<<"] ";
		//嵌套内容有错误，建议使用dumpDataTree方法，复杂数据格式更直观！
			oss<<"[cParentSysNo_u:"<<(int)cParentSysNo_u<<"] ";
			oss<<"[strFullName:"<<strFullName<<"] ";
			oss<<"[cFullName_u:"<<(int)cFullName_u<<"] ";
			oss<<"[strName:"<<strName<<"] ";
			oss<<"[cName_u:"<<(int)cName_u<<"] ";
			oss<<"[strCode:"<<strCode<<"] ";
			oss<<"[cCode_u:"<<(int)cCode_u<<"] ";
			oss<<"[strPinyinCode:"<<strPinyinCode<<"] ";
			oss<<"[cPinyinCode_u:"<<(int)cPinyinCode_u<<"] ";
		//嵌套内容有错误，建议使用dumpDataTree方法，复杂数据格式更直观！
			oss<<"[cStatus_u:"<<(int)cStatus_u<<"] ";
		//嵌套内容有错误，建议使用dumpDataTree方法，复杂数据格式更直观！
			oss<<"[cPropertyInclude_u:"<<(int)cPropertyInclude_u<<"] ";
			oss<<"[wPropertyOption:"<<(int)wPropertyOption<<"] ";
			oss<<"[cPropertyOption_u:"<<(int)cPropertyOption_u<<"] ";
		//嵌套内容有错误，建议使用dumpDataTree方法，复杂数据格式更直观！
			oss<<"[cPropertyExclude_u:"<<(int)cPropertyExclude_u<<"] ";

			std::map<std::string,std::string>::const_iterator itmapExtern=mapExtern.begin();
			std::map<std::string,std::string>::const_iterator itmapExternEnd=mapExtern.end();
			for(;itmapExtern!=itmapExternEnd;itmapExtern++)
				oss<<"[mapExtern:"<<itmapExtern->second<<"] ";
			oss<<"[cExtern_u:"<<(int)cExtern_u<<"] ";
		
		}

		// codydeng提供,非常好的dump方法 ^-^  。。。。。
		template<typename T>
		T & DumpPlusData(T& oss){
			oss<<"dwVersion:"<<dwVersion;
			oss<<"[cVersion_u:"<<cVersion_u<<"] ";
			oss<<"dwPage:"<<dwPage;
			oss<<"[cPage_u:"<<cPage_u<<"] ";
			oss<<"dwPageSize:"<<dwPageSize;
			oss<<"[cPageSize_u:"<<cPageSize_u<<"] ";
			oss<<"dwOrderType:"<<dwOrderType;
			oss<<"[cOrderType_u:"<<cOrderType_u<<"] ";
			oss<<"setParentSysNo:"<<setParentSysNo;
			oss<<"[cParentSysNo_u:"<<cParentSysNo_u<<"] ";
			oss<<"strFullName:"<<strFullName;
			oss<<"[cFullName_u:"<<cFullName_u<<"] ";
			oss<<"strName:"<<strName;
			oss<<"[cName_u:"<<cName_u<<"] ";
			oss<<"strCode:"<<strCode;
			oss<<"[cCode_u:"<<cCode_u<<"] ";
			oss<<"strPinyinCode:"<<strPinyinCode;
			oss<<"[cPinyinCode_u:"<<cPinyinCode_u<<"] ";
			oss<<"setStatus:"<<setStatus;
			oss<<"[cStatus_u:"<<cStatus_u<<"] ";
			oss<<"bitsetPropertyInclude:"<<bitsetPropertyInclude;
			oss<<"[cPropertyInclude_u:"<<cPropertyInclude_u<<"] ";
			oss<<"wPropertyOption:"<<wPropertyOption;
			oss<<"[cPropertyOption_u:"<<cPropertyOption_u<<"] ";
			oss<<"bitsetPropertyExclude:"<<bitsetPropertyExclude;
			oss<<"[cPropertyExclude_u:"<<cPropertyExclude_u<<"] ";
			oss<<"mapExtern:"<<mapExtern;
			oss<<"[cExtern_u:"<<cExtern_u<<"] ";
			return oss;
		}

		// wileywang提供,树形dump方法 ^-^  。。。。。
		void DumpDataTree(std::ostream& os, int ident = 0)const {
			g_pprint(os, "dwVersion", dwVersion, ident);
			g_pprint(os, "cVersion_u", cVersion_u, ident);
			g_pprint(os, "dwPage", dwPage, ident);
			g_pprint(os, "cPage_u", cPage_u, ident);
			g_pprint(os, "dwPageSize", dwPageSize, ident);
			g_pprint(os, "cPageSize_u", cPageSize_u, ident);
			g_pprint(os, "dwOrderType", dwOrderType, ident);
			g_pprint(os, "cOrderType_u", cOrderType_u, ident);
			g_pprint(os, "setParentSysNo", setParentSysNo, ident);
			g_pprint(os, "cParentSysNo_u", cParentSysNo_u, ident);
			g_pprint(os, "strFullName", strFullName, ident);
			g_pprint(os, "cFullName_u", cFullName_u, ident);
			g_pprint(os, "strName", strName, ident);
			g_pprint(os, "cName_u", cName_u, ident);
			g_pprint(os, "strCode", strCode, ident);
			g_pprint(os, "cCode_u", cCode_u, ident);
			g_pprint(os, "strPinyinCode", strPinyinCode, ident);
			g_pprint(os, "cPinyinCode_u", cPinyinCode_u, ident);
			g_pprint(os, "setStatus", setStatus, ident);
			g_pprint(os, "cStatus_u", cStatus_u, ident);
			g_pprint(os, "bitsetPropertyInclude", bitsetPropertyInclude, ident);
			g_pprint(os, "cPropertyInclude_u", cPropertyInclude_u, ident);
			g_pprint(os, "wPropertyOption", wPropertyOption, ident);
			g_pprint(os, "cPropertyOption_u", cPropertyOption_u, ident);
			g_pprint(os, "bitsetPropertyExclude", bitsetPropertyExclude, ident);
			g_pprint(os, "cPropertyExclude_u", cPropertyExclude_u, ident);
			g_pprint(os, "mapExtern", mapExtern, ident);
			g_pprint(os, "cExtern_u", cExtern_u, ident);
		}
		
		//提供ToString借口，默认为DumpData格式，请按需要进行修改
		std::string ToString() const{
			std::stringstream ss;
			DumpData(ss);
			return ss.str();
		}

/**
 ********************以下信息是每个版本的字段********************
 */

};

}
}
}

#endif /* ERP_ACCOUNT_DDO_CBUSINESSUNITSFILTERDDO_BY_AUTOGEN_V5_H */
